{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3a3b7d86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 词汇表： ['Kage', 'Niuzong', 'Xiaoxue', 'Mazong', 'Xiaobing', 'Teacher', 'is', 'Boss', 'Student']\n",
      " 词汇到索引的字典： {'Kage': 0, 'Niuzong': 1, 'Xiaoxue': 2, 'Mazong': 3, 'Xiaobing': 4, 'Teacher': 5, 'is': 6, 'Boss': 7, 'Student': 8}\n",
      " 索引到词汇的字典： {0: 'Kage', 1: 'Niuzong', 2: 'Xiaoxue', 3: 'Mazong', 4: 'Xiaobing', 5: 'Teacher', 6: 'is', 7: 'Boss', 8: 'Student'}\n",
      " 词汇表大小： 9\n"
     ]
    }
   ],
   "source": [
    "# 定义一个句子列表，后面会用这些句子来训练 CBOW 和 Skip-Gram 模型\n",
    "sentences = [\"Kage is Teacher\", \"Mazong is Boss\", \"Niuzong is Boss\",\n",
    "             \"Xiaobing is Student\", \"Xiaoxue is Student\",]\n",
    "# 将所有句子连接在一起，然后用空格分隔成多个单词\n",
    "words = ' '.join(sentences).split()\n",
    "# 构建词汇表，去除重复的词\n",
    "word_list = list(set(words))\n",
    "# 创建一个字典，将每个词映射到一个唯一的索引\n",
    "word_to_idx = {word: idx for idx, word in enumerate(word_list)}\n",
    "# 创建一个字典，将每个索引映射到对应的词\n",
    "idx_to_word = {idx: word for idx, word in enumerate(word_list)}\n",
    "voc_size = len(word_list) # 计算词汇表的大小\n",
    "print(\" 词汇表：\", word_list) # 输出词汇表\n",
    "print(\" 词汇到索引的字典：\", word_to_idx) # 输出词汇到索引的字典\n",
    "print(\" 索引到词汇的字典：\", idx_to_word) # 输出索引到词汇的字典\n",
    "print(\" 词汇表大小：\", voc_size) # 输出词汇表大小"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a78a1f96",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Skip-Gram 数据样例（未编码）： [('is', 'Kage'), ('Teacher', 'Kage'), ('Kage', 'is')]\n"
     ]
    }
   ],
   "source": [
    "# 生成 Skip-Gram 训练数据\n",
    "def create_skipgram_dataset(sentences, window_size=2):\n",
    "    data = [] # 初始化数据\n",
    "    for sentence in sentences: # 遍历句子\n",
    "        sentence = sentence.split()  # 将句子分割成单词列表\n",
    "        for idx, word in enumerate(sentence):  # 遍历单词及其索引\n",
    "            # 获取相邻的单词，将当前单词前后各 N 个单词作为相邻单词\n",
    "            for neighbor in sentence[max(idx - window_size, 0): \n",
    "                        min(idx + window_size + 1, len(sentence))]:\n",
    "                if neighbor != word:  # 排除当前单词本身\n",
    "                    # 将相邻单词与当前单词作为一组训练数据\n",
    "                    # data.append((neighbor, word))\n",
    "                    data.append((word, neighbor))\n",
    "    return data\n",
    "# 使用函数创建 Skip-Gram 训练数据\n",
    "skipgram_data = create_skipgram_dataset(sentences)\n",
    "# 打印未编码的 Skip-Gram 数据样例（前 3 个）\n",
    "print(\"Skip-Gram 数据样例（未编码）：\", skipgram_data[:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "56fd0f7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "One-Hot 编码前的单词： Teacher\n",
      "One-Hot 编码后的向量： tensor([0., 0., 0., 0., 0., 1., 0., 0., 0.])\n",
      "Skip-Gram数据样例（已编码）： [(tensor([1., 0., 0., 0., 0., 0., 0., 0., 0.]), 6), (tensor([1., 0., 0., 0., 0., 0., 0., 0., 0.]), 5), (tensor([0., 0., 0., 0., 0., 0., 1., 0., 0.]), 0)]\n"
     ]
    }
   ],
   "source": [
    "# 定义 One-Hot 编码函数\n",
    "import torch # 导入 torch 库\n",
    "def one_hot_encoding(word, word_to_idx):    \n",
    "    tensor = torch.zeros(len(word_to_idx)) # 创建一个长度与词汇表相同的全 0 张量  \n",
    "    tensor[word_to_idx[word]] = 1  # 将对应词的索引设为 1\n",
    "    return tensor  # 返回生成的 One-Hot 向量\n",
    "# 展示 One-Hot 编码前后的数据\n",
    "word_example = \"Teacher\"\n",
    "print(\"One-Hot 编码前的单词：\", word_example)\n",
    "print(\"One-Hot 编码后的向量：\", one_hot_encoding(word_example, word_to_idx))\n",
    "# 展示编码后的 Skip-Gram 训练数据样例\n",
    "print(\"Skip-Gram数据样例（已编码）：\", [(one_hot_encoding(target, word_to_idx), \n",
    "                               word_to_idx[context]) for context, target in skipgram_data[:3]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fd3726b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Skip-Gram 模型： SkipGram(\n",
      "  (input_to_hidden): Linear(in_features=9, out_features=2, bias=False)\n",
      "  (hidden_to_output): Linear(in_features=2, out_features=9, bias=False)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# 定义 Skip-Gram 类\n",
    "import torch.nn as nn # 导入 neural network\n",
    "class SkipGram(nn.Module):\n",
    "    def __init__(self, voc_size, embedding_size):\n",
    "        super(SkipGram, self).__init__()\n",
    "        # 从词汇表大小到嵌入层大小（维度）的线性层（权重矩阵）\n",
    "        self.input_to_hidden = nn.Linear(voc_size, embedding_size, bias=False)  \n",
    "        # 从嵌入层大小（维度）到词汇表大小的线性层（权重矩阵）\n",
    "        self.hidden_to_output = nn.Linear(embedding_size, voc_size, bias=False)  \n",
    "    def forward(self, X): # 前向传播的方式，X 形状为 (batch_size, voc_size)      \n",
    "         # 通过隐藏层，hidden 形状为 (batch_size, embedding_size)\n",
    "            hidden = self.input_to_hidden(X) \n",
    "            # 通过输出层，output_layer 形状为 (batch_size, voc_size)\n",
    "            output = self.hidden_to_output(hidden)  \n",
    "            return output    \n",
    "embedding_size = 2 # 设定嵌入层的大小，这里选择 2 是为了方便展示\n",
    "skipgram_model = SkipGram(voc_size, embedding_size)  # 实例化 Skip-Gram 模型\n",
    "print(\"Skip-Gram 模型：\", skipgram_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "65cb5973",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 100, Loss: 2.206050093968709\n",
      "Epoch: 200, Loss: 2.1944000005722044\n",
      "Epoch: 300, Loss: 2.182283655802409\n",
      "Epoch: 400, Loss: 2.167587486902873\n",
      "Epoch: 500, Loss: 2.147610100110372\n",
      "Epoch: 600, Loss: 2.1189597725868223\n",
      "Epoch: 700, Loss: 2.0784456014633177\n",
      "Epoch: 800, Loss: 2.02604193687439\n",
      "Epoch: 900, Loss: 1.9687333305676777\n",
      "Epoch: 1000, Loss: 1.9178066511948904\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 训练 Skip-Gram 类\n",
    "learning_rate = 0.001 # 设置学习速率\n",
    "epochs = 1000 # 设置训练轮次\n",
    "criterion = nn.CrossEntropyLoss()  # 定义交叉熵损失函数\n",
    "import torch.optim as optim # 导入随机梯度下降优化器\n",
    "optimizer = optim.SGD(skipgram_model.parameters(), lr=learning_rate)  \n",
    "# 开始训练循环\n",
    "loss_values = []  # 用于存储每轮的平均损失值\n",
    "for epoch in range(epochs):\n",
    "    loss_sum = 0 # 初始化损失值\n",
    "    # for context, target in skipgram_data:   \n",
    "    for center_word, context in skipgram_data:     \n",
    "        X = one_hot_encoding(center_word, word_to_idx).float().unsqueeze(0) # 将中心词转换为 One-Hot 向量  \n",
    "        y_true = torch.tensor([word_to_idx[context]], dtype=torch.long) # 将周围词转换为索引值 \n",
    "        y_pred = skipgram_model(X)  # 计算预测值\n",
    "        loss = criterion(y_pred, y_true)  # 计算损失\n",
    "        loss_sum += loss.item() # 累积损失\n",
    "        optimizer.zero_grad()  # 清空梯度\n",
    "        loss.backward()  # 反向传播\n",
    "        optimizer.step()  # 更新参数\n",
    "    if (epoch+1) % 100 == 0: # 输出每 100 轮的损失，并记录损失\n",
    "      print(f\"Epoch: {epoch+1}, Loss: {loss_sum/len(skipgram_data)}\")  \n",
    "      loss_values.append(loss_sum / len(skipgram_data))\n",
    "# 绘制训练损失曲线\n",
    "import matplotlib.pyplot as plt # 导入 matplotlib\n",
    "# 绘制二维词向量图\n",
    "plt.rcParams[\"font.family\"]=['SimHei'] # 用来设定字体样式\n",
    "plt.rcParams['font.sans-serif']=['SimHei'] # 用来设定无衬线字体样式\n",
    "plt.rcParams['axes.unicode_minus']=False # 用来正常显示负号\n",
    "plt.plot(range(1, epochs//100 + 1), loss_values) # 绘图\n",
    "plt.title(' 训练损失曲线 ') # 图题\n",
    "plt.xlabel(' 轮次 ') # X 轴 Label\n",
    "plt.ylabel(' 损失 ') # Y 轴 Label\n",
    "plt.show() # 显示图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b9ba6bcb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Skip-Gram 词嵌入：\n",
      "Kage: [0.61016065 0.7306773 ]\n",
      "Niuzong: [-0.12686515  0.38882658]\n",
      "Xiaoxue: [0.16116168 0.41416478]\n",
      "Mazong: [-0.10384143  0.38075024]\n",
      "Xiaobing: [0.30230978 0.45506486]\n",
      "Teacher: [ 0.47190428 -0.12305872]\n",
      "is: [-0.08106854 -0.480878  ]\n",
      "Boss: [-0.23589657  1.1961255 ]\n",
      "Student: [0.1537026  0.69835067]\n"
     ]
    }
   ],
   "source": [
    "# 输出 Skip-Gram 习得的词嵌入\n",
    "print(\"Skip-Gram 词嵌入：\")\n",
    "for word, idx in word_to_idx.items(): # 输出每个词的嵌入向量\n",
    " print(f\"{word}: {skipgram_model.input_to_hidden.weight[:,idx].detach().numpy()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e58f6b82",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots() \n",
    "for word, idx in word_to_idx.items():\n",
    "    # 获取每个单词的嵌入向量\n",
    "    vec = skipgram_model.input_to_hidden.weight[:,idx].detach().numpy() \n",
    "    ax.scatter(vec[0], vec[1]) # 在图中绘制嵌入向量的点\n",
    "    ax.annotate(word, (vec[0], vec[1]), fontsize=12) # 点旁添加单词标签\n",
    "plt.title(' 二维词嵌入 ') # 图题\n",
    "plt.xlabel(' 向量维度 1') # X 轴 Label\n",
    "plt.ylabel(' 向量维度 2') # Y 轴 Label\n",
    "plt.show() # 显示图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a329336",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
